<template>
  <XenPageLayout
    title="编辑调岗调薪"
    title-align="left"
    navbar-bg-color="#7881de"
    navbar-text-color="#ffffff"
    navbar-icon-color="#ffffff"
    contentStyle="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 0; height: 100vh; display: flex; flex-direction: column;"
  >
    <!-- 表单内容区域 -->
    <view class="form-container">
      <XenDynamicFormCard
        title="编辑调岗调薪信息"
        :subtitle="`申请单ID: ${transferId || ''}`"
        :sections="formSections"
        :modelValue="formData"
        :errors="formErrors"
        :showFooter="false"
        @update:modelValue="handleFormDataChange"
        @fieldBlur="handleFieldBlur"
        @pickerChange="handlePickerChange"
        @datetimeChange="handleDateTimeChange"
        @imageUpload="handleImageUpload"
        @imageSuccess="handleImageSuccess"
        @imageFail="handleImageFail"
        @imageDelete="handleImageDelete"
        @fileUpload="handleFileUpload"
        @fileSuccess="handleFileSuccess"
        @fileFail="handleFileFail"
        @fileDelete="handleFileDelete"
        @attachmentUpload="handleAttachmentUpload"
        @attachmentDelete="handleAttachmentDelete"
        @attachmentPreview="handleAttachmentPreview"
        @departmentPickerChange="handleDepartmentPickerChange"
        @departmentPickerOpen="handleDepartmentPickerOpen"
        @departmentPickerClose="handleDepartmentPickerClose"
        @autoCompleteChange="handleAutoCompleteChange"
        @autoCompleteSearch="handleAutoCompleteSearch"
      />
    </view>

    <!-- 固定底部操作按钮 -->
    <XenFormActions
      :actions="formActions"
      :hidden="isDepartmentPickerOpen"
      @action="handleFormAction"
    />
  </XenPageLayout>
</template>

<script setup lang="ts">
import { onMounted, ref, computed, watch } from "vue";
import { onLoad } from "@dcloudio/uni-app";
import XenPageLayout from "@/layouts/XenPageLayout.vue";
import XenDynamicFormCard from "@/components/XenDynamicFormCard.vue";
import XenFormActions from "@/components/XenFormActions.vue";
import {
  getFormSectionsByPageType,
  getDynamicFormSections,
  transferFormConfig,
} from "./form-config";
import { useTransferInfo } from "./composables/useInfo";
// 导入统一事件系统
import { ResignInfoEvents } from "@/utils/eventBus";
// 导入文件上传工具
import { uploadImage } from "@/utils/unirequest";

// 部门数据加载状态（模块级变量，避免window对象问题）
let departmentLoadingInProgress = false;

// 导入API和接口类型
import SysHrTransferRequestBillApi from "./api/index";
import type { ISysHrTransferRequestBillVm } from "./api/interface";
import commonApi from "@/api/common";
import type { ICompanyItem } from "@/type/common";

// 获取路由参数
const transferId = ref<string>("");

// 创建API实例
const api = SysHrTransferRequestBillApi();
const commonApiInstance = commonApi();

// 公司列表数据
const companyList = ref<ICompanyItem[]>([]);

// 部门列表数据
const departmentList = ref<any[]>([]);

// 审核权限标识
const isMyApprove = ref<boolean>(false);

// 部门选择器打开状态
const isDepartmentPickerOpen = ref<boolean>(false);

// 强制更新触发器
const forceUpdateTrigger = ref(0);

// 获取编辑页面的表单分组（动态计算禁用状态和选项）
const formSections = computed(() => {
  // 依赖强制更新触发器，确保响应式更新
  forceUpdateTrigger.value;

  const sections = getDynamicFormSections(formData.transferType || "", "edit");

  // 动态设置字段的数据和状态
  sections.forEach((section) => {
    section.fields.forEach((field) => {
      // 处理新部门字段 - 直接使用配置中的部门数据
      if (field.key === "newGroupId") {
        const originalField = transferFormConfig.newGroupId;
        if (originalField) {
          field.departmentData = originalField.departmentData || [];
          field.optionsData = originalField.optionsData || [];
        }
      }

      // 处理原部门字段 - 直接使用配置中的部门数据
      if (field.key === "originalGroupId") {
        const originalField = transferFormConfig.originalGroupId;
        if (originalField) {
          field.departmentData = originalField.departmentData || [];
          field.optionsData = originalField.optionsData || [];
        }
      }

      // 处理新岗位字段 - 动态岗位选项
      if (field.key === "newJobPositionId") {
        field.disabled = isPositionFieldDisabled("newJobPositionId");
        field.options = getPositionOptionsText("newJobPositionId");
        field.optionsData = getPositionOptions("newJobPositionId");

        // 调试picker字段配置
        console.log("🔍 新岗位picker字段配置:", {
          key: field.key,
          disabled: field.disabled,
          options: field.options,
          optionsData: field.optionsData,
          currentValue: formData.newJobPositionId,
        });

        // 检查当前值是否在选项中存在
        const hasCurrentOption = field.optionsData?.find(
          (opt: any) => opt.value === formData.newJobPositionId,
        );
        console.log("🔍 当前值在选项中存在？", hasCurrentOption);

        // 如果不存在，手动添加
        if (
          !hasCurrentOption &&
          formData.newJobPositionId &&
          formData.newPositionName
        ) {
          console.log("⚠️ 当前选项不存在，手动添加");
          const newOption = {
            value: formData.newJobPositionId,
            text: formData.newPositionName,
          };
          field.optionsData = field.optionsData || [];
          field.optionsData.unshift(newOption); // 添加到开头
          field.options = field.options || [];
          field.options.unshift(formData.newPositionName);
          console.log("✅ 已添加选项:", newOption);
        }
      }

      // 处理原岗位字段 - 动态岗位选项
      if (field.key === "originalPositionId") {
        field.disabled = isPositionFieldDisabled("originalPositionId");
        field.options = getPositionOptionsText("originalPositionId");
        field.optionsData = getPositionOptions("originalPositionId");

        // 调试picker字段配置
        console.log("🔍 原岗位picker字段配置:", {
          key: field.key,
          disabled: field.disabled,
          options: field.options,
          optionsData: field.optionsData,
          currentValue: formData.originalPositionId,
        });

        // 检查当前值是否在选项中存在
        const hasCurrentOption = field.optionsData?.find(
          (opt: any) => opt.value === formData.originalPositionId,
        );
        console.log("🔍 当前值在选项中存在？", hasCurrentOption);

        // 如果不存在，手动添加
        if (
          !hasCurrentOption &&
          formData.originalPositionId &&
          formData.originalPositionName
        ) {
          console.log("⚠️ 当前选项不存在，手动添加");
          const newOption = {
            value: formData.originalPositionId,
            text: formData.originalPositionName,
          };
          field.optionsData = field.optionsData || [];
          field.optionsData.unshift(newOption); // 添加到开头
          field.options = field.options || [];
          field.options.unshift(formData.originalPositionName);
          console.log("✅ 已添加选项:", newOption);
        }
      }
    });
  });

  return sections;
});

// 表单操作按钮配置
const formActions = computed(() => [
  {
    key: "save",
    label: isMyApprove.value ? "取消" : "保存",
    type: "success" as const,
  },
  {
    key: "submit",
    label: "提交",
    type: "primary" as const,
  },
]);

// 使用调岗调薪申请信息 Composable
const {
  formData,
  formErrors,
  pickerValues,
  validateField,
  handlePickerChange,
  handleDateTimeChange,
  initializeOptions,
  loadTransferDetail,
  search,
  originalData,
  convertFormDataToApiFormatForEdit,
  // 部门岗位联动相关方法
  loadOriginalPositionsByDepartment,
  loadPositionsByDepartment,
  handleDepartmentChange,
  isPositionFieldDisabled,
  getPositionOptions,
  getPositionOptionsText,
  // 部门数据更新方法
  updateDepartmentData,
  ensureDepartmentDataAvailable,
  // 动态验证方法
  validateDynamicFormFields,
  // 岗位选择处理方法
  handleOriginalPositionChange,
  handleNewPositionChange,
} = useTransferInfo();

// 获取公司列表
const loadCompanyList = async () => {
  try {
    const response = await commonApiInstance.GetUserCompanies();
    companyList.value = response || [];
  } catch (error) {
    companyList.value = [];
  }
};

// 获取部门列表
const loadDepartmentList = async () => {
  try {
    const response = await commonApiInstance.GetParentsTree(false);
    departmentList.value = response || [];
  } catch (error) {
    departmentList.value = [];
  }
};

// 根据公司ID获取公司名称
const getCompanyNameById = (orgId: string | null): string => {
  if (!orgId || !companyList.value.length) return "";

  const company = companyList.value.find((item) => item.Value === orgId);
  return company ? company.Text : "";
};

// 根据部门ID获取部门名称（递归查找，支持多级部门）
const getDepartmentNameById = (groupId: string | null): string => {
  if (!groupId || !departmentList.value.length) return "";

  // 递归查找部门
  const findDepartmentById = (departments: any[], id: string): any => {
    for (const dept of departments) {
      if (dept.ID === id || dept.Value === id) {
        return dept;
      }
      if (dept.Children && dept.Children.length > 0) {
        const found = findDepartmentById(dept.Children, id);
        if (found) return found;
      }
    }
    return null;
  };

  const department = findDepartmentById(departmentList.value, groupId);
  return department
    ? department.Text || department.GroupName || department.Name
    : "";
};

// 处理公司信息回显
const processCompanyInfo = () => {
  if (originalData.value?.OrgId && !formData.orgName) {
    const companyName = getCompanyNameById(originalData.value.OrgId);
    if (companyName) {
      formData.orgName = companyName;
    }
  }
};

// 处理部门信息回显
const processDepartmentInfo = () => {
  if (!originalData.value) return;

  // 处理当前所属部门
  if (formData.groupId && !formData.groupName) {
    const departmentName = getDepartmentNameById(formData.groupId);
    if (departmentName) {
      formData.groupName = departmentName;
    }
  }

  // 处理原部门信息 - 现在ID字段正确映射了
  if (formData.originalGroupId && !formData.originalGroupName) {
    const originalDepartmentName = getDepartmentNameById(
      formData.originalGroupId,
    );
    if (originalDepartmentName) {
      formData.originalGroupName = originalDepartmentName;
    }
  }

  // 处理新部门信息 - 现在ID字段正确映射了
  if (formData.newGroupId && !formData.newGroupName) {
    const newDepartmentName = getDepartmentNameById(formData.newGroupId);
    if (newDepartmentName) {
      formData.newGroupName = newDepartmentName;
    }
  }
};

// 根据岗位ID获取岗位名称
const getPositionNameById = (
  positionId: string | null,
  positionList: any[],
): string => {
  console.log("🔍 getPositionNameById 调用:", {
    positionId,
    positionListLength: positionList.length,
  });

  if (!positionId || !positionList.length) {
    console.log("⚠️ ID为空或列表为空，返回空字符串");
    return "";
  }

  // 尝试多种匹配方式，处理Vue Proxy代理对象问题
  let position = positionList.find((item) => {
    const itemValue = item.value || item.Value || item.id || item.Id;
    console.log("🔍 比较:", {
      itemValue,
      positionId,
      equal: itemValue === positionId,
    });
    return itemValue === positionId;
  });

  // 如果还是找不到，尝试字符串转换
  if (!position) {
    position = positionList.find((item) => {
      const itemValue = String(item.value || item.Value || item.id || item.Id);
      const targetId = String(positionId);
      console.log("🔍 字符串比较:", {
        itemValue,
        targetId,
        equal: itemValue === targetId,
      });
      return itemValue === targetId;
    });
  }

  // 如果还是找不到，尝试去除前后空格
  if (!position) {
    position = positionList.find((item) => {
      const itemValue = String(
        item.value || item.Value || item.id || item.Id,
      ).trim();
      const targetId = String(positionId).trim();
      console.log("🔍 去空格比较:", {
        itemValue,
        targetId,
        equal: itemValue === targetId,
      });
      return itemValue === targetId;
    });
  }

  console.log("🔍 找到的岗位选项:", position);

  if (position) {
    const name =
      position.text || position.Text || position.Name || position.name;
    console.log("🔍 提取的岗位名称:", name);
    return name;
  } else {
    console.warn("❌ 未找到匹配的岗位选项，ID:", positionId);
    // 打印前几个选项的结构供参考
    if (positionList.length > 0) {
      console.log("🔍 参考：前3个选项的结构:", positionList.slice(0, 3));
    }
    return "";
  }
};

// 处理岗位信息回显 - 简化版本：直接根据部门ID加载岗位列表并回显名称
const processPositionInfo = async () => {
  console.log("🔍 处理岗位信息回显开始", {
    originalGroupId: formData.originalGroupId,
    originalPositionId: formData.originalPositionId,
    originalPositionName: formData.originalPositionName,
    newGroupId: formData.newGroupId,
    newJobPositionId: formData.newJobPositionId,
    newPositionName: formData.newPositionName,
  });

  // 如果有原部门ID，加载原部门的岗位列表
  if (formData.originalGroupId) {
    console.log("🔍 加载原部门岗位列表...", formData.originalGroupId);
    try {
      await loadOriginalPositionsByDepartment(formData.originalGroupId);
      console.log("✅ 原部门岗位列表加载完成");
    } catch (error) {
      console.error("❌ 加载原部门岗位列表失败:", error);
    }

    // 如果有原岗位ID，从列表中查找名称（移除名称为空的限制）
    if (formData.originalPositionId) {
      const originalPositionOptions = getPositionOptions("originalPositionId");
      console.log("🔍 原岗位选项列表:", originalPositionOptions);
      console.log("🔍 原岗位选项列表长度:", originalPositionOptions.length);

      // 详细检查选项数据结构
      if (originalPositionOptions.length > 0) {
        console.log("🔍 第一个原岗位选项结构:", originalPositionOptions[0]);
        console.log("🔍 第二个原岗位选项结构:", originalPositionOptions[1]);
        console.log("🔍 原岗位ID要查找的值:", formData.originalPositionId);
        console.log("🔍 原岗位ID类型:", typeof formData.originalPositionId);

        // 检查是否有任何选项的value匹配
        const matchingOption = originalPositionOptions.find(
          (option: any) => option.value === formData.originalPositionId,
        );
        console.log("🔍 找到的匹配选项:", matchingOption);
      }

      if (originalPositionOptions.length === 0) {
        console.warn("⚠️ 原岗位选项列表为空，可能是API调用失败或返回空数据");
        console.log("🔍 尝试直接从API获取岗位数据进行验证...");

        // 直接调用API验证
        try {
          const api = SysHrTransferRequestBillApi();
          const directApiResult = await api.getSysJobPositions(
            formData.originalGroupId,
          );
          console.log("🔍 直接API调用结果:", directApiResult);
          console.log("🔍 直接API调用结果类型:", typeof directApiResult);
          console.log("🔍 直接API调用结果长度:", directApiResult?.length);

          if (directApiResult && directApiResult.length > 0) {
            console.log(
              "✅ 直接API调用成功，返回了数据，说明loadOriginalPositionsByDepartment有问题",
            );
            console.log("🔍 第一个岗位数据结构:", directApiResult[0]);
          } else {
            console.log(
              "❌ 直接API调用也返回空数据，可能是后端问题或部门ID无效",
            );
          }
        } catch (directApiError) {
          console.error("❌ 直接API调用失败:", directApiError);
        }
      }

      const originalPositionName = getPositionNameById(
        formData.originalPositionId,
        originalPositionOptions,
      );
      console.log("🔍 根据ID查找到的原岗位名称:", originalPositionName);
      if (
        originalPositionName &&
        originalPositionName !== formData.originalPositionName
      ) {
        // 关键：picker 显示用文本，提交用 ID
        const originalId = formData.originalPositionId;
        formData.originalPositionName = originalPositionName;
        // 显示：把表单当前显示值替换为名称
        formData.originalPositionId = originalPositionName as any;
        // 提交：把真实ID写入pickerValues
        pickerValues.originalPositionId = originalId as any;
        // 如果组件是以文本显示当前 value，则临时把 formData.originalPositionId 也设置为文本以避免显示 ID
        // XenDynamicFormCard 在显示时会优先用 options 与当前 value 匹配；
        // 若组件仍显示 value 本身，这里把显示值覆盖为名称可兜底
        // 注意：提交时 convertFormDataToApiFormatForEdit 会使用 pickerValues
        if (
          Array.isArray(originalPositionOptions) &&
          originalPositionOptions.length > 0
        ) {
          // 确保 options 中存在当前项
          const exist = originalPositionOptions.find(
            (o: any) => o.value === pickerValues.originalPositionId,
          );
          if (!exist) {
            transferFormConfig.originalPositionId.optionsData = [
              {
                value: pickerValues.originalPositionId,
                text: originalPositionName,
              },
              ...getPositionOptions("originalPositionId"),
            ];
            transferFormConfig.originalPositionId.options = [
              originalPositionName,
              ...getPositionOptionsText("originalPositionId"),
            ];
          }
        }
        console.log("✅ 设置原岗位名称:", originalPositionName);

        // 强制触发表单重新计算，确保picker显示正确文本
        forceUpdateTrigger.value++;
        console.log("🔄 强制更新表单显示");
      } else if (!originalPositionName) {
        console.warn(
          "⚠️ 未能根据ID找到原岗位名称，ID:",
          formData.originalPositionId,
        );
      }
    }
  }

  // 如果有新部门ID，加载新部门的岗位列表
  if (formData.newGroupId) {
    console.log("🔍 加载新部门岗位列表...", formData.newGroupId);
    try {
      await loadPositionsByDepartment(formData.newGroupId);
      console.log("✅ 新部门岗位列表加载完成");
    } catch (error) {
      console.error("❌ 加载新部门岗位列表失败:", error);
    }

    // 如果有新岗位ID，从列表中查找名称（移除名称为空的限制）
    if (formData.newJobPositionId) {
      const newPositionOptions = getPositionOptions("newJobPositionId");
      console.log("🔍 新岗位选项列表:", newPositionOptions);
      console.log("🔍 新岗位选项列表长度:", newPositionOptions.length);

      // 详细检查选项数据结构
      if (newPositionOptions.length > 0) {
        console.log("🔍 第一个新岗位选项结构:", newPositionOptions[0]);
        console.log("🔍 第二个新岗位选项结构:", newPositionOptions[1]);
        console.log("🔍 新岗位ID要查找的值:", formData.newJobPositionId);
        console.log("🔍 新岗位ID类型:", typeof formData.newJobPositionId);

        // 检查是否有任何选项的value匹配
        const matchingOption = newPositionOptions.find(
          (option: any) => option.value === formData.newJobPositionId,
        );
        console.log("🔍 找到的匹配选项:", matchingOption);
      }

      if (newPositionOptions.length === 0) {
        console.warn("⚠️ 新岗位选项列表为空，可能是API调用失败或返回空数据");
        console.log("🔍 尝试直接从API获取岗位数据进行验证...");

        // 直接调用API验证
        try {
          const api = SysHrTransferRequestBillApi();
          const directApiResult = await api.getSysJobPositions(
            formData.newGroupId,
          );
          console.log("🔍 新岗位直接API调用结果:", directApiResult);
          console.log("🔍 新岗位直接API调用结果类型:", typeof directApiResult);
          console.log("🔍 新岗位直接API调用结果长度:", directApiResult?.length);

          if (directApiResult && directApiResult.length > 0) {
            console.log(
              "✅ 新岗位直接API调用成功，返回了数据，说明loadPositionsByDepartment有问题",
            );
            console.log("🔍 新岗位第一个岗位数据结构:", directApiResult[0]);
          } else {
            console.log(
              "❌ 新岗位直接API调用也返回空数据，可能是后端问题或部门ID无效",
            );
          }
        } catch (directApiError) {
          console.error("❌ 新岗位直接API调用失败:", directApiError);
        }
      }

      const newPositionName = getPositionNameById(
        formData.newJobPositionId,
        newPositionOptions,
      );
      console.log("🔍 根据ID查找到的新岗位名称:", newPositionName);
      if (newPositionName && newPositionName !== formData.newPositionName) {
        const newId = formData.newJobPositionId;
        formData.newPositionName = newPositionName;
        // 显示：把表单当前显示值替换为名称
        formData.newJobPositionId = newPositionName as any;
        // 提交：把真实ID写入pickerValues
        pickerValues.newJobPositionId = newId as any;
        if (
          Array.isArray(newPositionOptions) &&
          newPositionOptions.length > 0
        ) {
          const exist = newPositionOptions.find(
            (o: any) => o.value === pickerValues.newJobPositionId,
          );
          if (!exist) {
            transferFormConfig.newJobPositionId.optionsData = [
              { value: pickerValues.newJobPositionId, text: newPositionName },
              ...getPositionOptions("newJobPositionId"),
            ];
            transferFormConfig.newJobPositionId.options = [
              newPositionName,
              ...getPositionOptionsText("newJobPositionId"),
            ];
          }
        }
        console.log("✅ 设置新岗位名称:", newPositionName);

        // 强制触发表单重新计算，确保picker显示正确文本
        forceUpdateTrigger.value++;
        console.log("🔄 强制更新表单显示");
      } else if (!newPositionName) {
        console.warn(
          "⚠️ 未能根据ID找到新岗位名称，ID:",
          formData.newJobPositionId,
        );
      }
    }
  }

  console.log("🔍 处理岗位信息回显完成");
};

// 表单数据变化处理
const handleFormDataChange = (newData: Record<string, any>) => {
  Object.assign(formData, newData);
};

// 字段失焦处理
const handleFieldBlur = (fieldKey: string) => {
  validateField(fieldKey);
};

// 部门选择器变化处理
const handleDepartmentPickerChange = async (
  fieldKey: string,
  value: string,
  _item: any,
) => {
  // XenDynamicFormCard组件会同时触发 @update:model-value 和 @change 事件
  // @update:model-value 已经通过 handleFormDataChange 设置了 formData[fieldKey] = value (部门ID)
  // 这里我们只需要保存部门ID到pickerValues中，用于提交到后端

  // 确保formData中存储的是部门ID（用于组件正确显示选中状态）
  formData[fieldKey] = value;

  // 同时保存到pickerValues中（用于提交到后端）
  pickerValues[fieldKey] = value;

  // 处理部门变化时的岗位联动逻辑
  await handleDepartmentChange(fieldKey, value);

  // 触发验证
  validateField(fieldKey);
};

// 部门选择器弹框打开处理
const handleDepartmentPickerOpen = () => {
  isDepartmentPickerOpen.value = true;
};

// 部门选择器弹框关闭处理
const handleDepartmentPickerClose = () => {
  isDepartmentPickerOpen.value = false;
};

// 自动补全变化处理
const handleAutoCompleteChange = (
  fieldKey: string,
  _value: string,
  option: any,
) => {
  // 对于自动补全，formData中存储显示文本，pickerValues中存储实际值
  if (option) {
    formData[fieldKey] = option.text;
    pickerValues[fieldKey] = option.value;

    // 如果是员工选择，自动填入员工工号、姓名、公司和所属部门
    if (fieldKey === "personId") {
      if (option.subtitle) {
        // 从subtitle中提取工号，格式为 "工号: 12345 | 部门名称"
        const staffNoMatch = option.subtitle.match(/工号:\s*(\S+)/);
        if (staffNoMatch) {
          formData.staffNo = staffNoMatch[1];
        }
      }
      // 员工姓名就是选中的文本
      formData.name = option.text;

      // 填充公司和部门信息（从扩展数据中获取）
      if (option.extData) {
        // 公司信息
        if (option.extData.orgId) {
          formData.orgId = option.extData.orgId;
          pickerValues.orgId = option.extData.orgId;
        }
        if (option.extData.orgName) {
          formData.orgName = option.extData.orgName;
        }

        // 所属部门信息
        if (option.extData.groupId) {
          formData.groupId = option.extData.groupId;
          pickerValues.groupId = option.extData.groupId;
        }
        if (option.extData.groupName) {
          formData.groupName = option.extData.groupName;
        }
      }
    }
  } else {
    formData[fieldKey] = "";
    pickerValues[fieldKey] = "";

    // 如果清空员工选择，也清空相关字段
    if (fieldKey === "personId") {
      formData.staffNo = "";
      formData.name = "";
      formData.orgId = "";
      formData.orgName = "";
      formData.groupId = "";
      formData.groupName = "";
      pickerValues.orgId = "";
      pickerValues.groupId = "";
    }
  }

  // 触发验证
  validateField(fieldKey);
};

// 自动补全搜索处理
const handleAutoCompleteSearch = async (fieldKey: string, query: string) => {
  // 搜索逻辑已经在组件内部通过searchApi处理
};

// 获取文件URL
const getFileUrl = (fileId: string | null) => {
  if (!fileId) return "";
  return `${import.meta.env.VITE_BASE_URL}/api/_file/getfile/${fileId}`;
};

// 获取路由参数
onLoad((options) => {
  if (options?.id) {
    transferId.value = options.id;
  } else {
    uni.showToast({
      title: "缺少ID参数",
      icon: "none",
    });
  }
});

// 监听岗位选项变化，强制重新计算表单配置，并处理岗位名称回显
watch(
  () => [
    getPositionOptions("newJobPositionId").length,
    formData.newGroupId,
    getPositionOptions("originalPositionId").length,
    formData.originalGroupId,
  ],
  async ([
    newPositionOptionsLength,
    newGroupId,
    originalPositionOptionsLength,
    originalGroupId,
  ]) => {
    forceUpdateTrigger.value++;

    // 简化逻辑：当有岗位选项且有岗位ID时，直接设置名称（不管原来是否有名称）
    if (formData.newJobPositionId && newPositionOptionsLength > 0) {
      const newPositionOptions = getPositionOptions("newJobPositionId");
      const newPositionName = getPositionNameById(
        formData.newJobPositionId,
        newPositionOptions,
      );
      if (newPositionName && newPositionName !== formData.newPositionName) {
        formData.newPositionName = newPositionName;
      }
    }

    if (formData.originalPositionId && originalPositionOptionsLength > 0) {
      const originalPositionOptions = getPositionOptions("originalPositionId");
      const originalPositionName = getPositionNameById(
        formData.originalPositionId,
        originalPositionOptions,
      );
      if (
        originalPositionName &&
        originalPositionName !== formData.originalPositionName
      ) {
        formData.originalPositionName = originalPositionName;
      }
    }
  },
  { deep: true },
);

// 监听调整类型变化，动态更新表单分组
watch(
  () => formData.transferType,
  async (newTransferType) => {
    // 如果切换到包含部门字段的调整类型，确保部门数据可用
    if (newTransferType && newTransferType !== "薪资调整") {
      if (!departmentLoadingInProgress) {
        departmentLoadingInProgress = true;
        try {
          await ensureDepartmentDataAvailable();
        } finally {
          departmentLoadingInProgress = false;
        }
      }
    }

    forceUpdateTrigger.value++;
  },
  { immediate: false },
);

// 监听公司列表和部门列表变化，处理信息回显
watch(
  () => [companyList.value.length, departmentList.value.length],
  async ([companyLength, departmentLength]) => {
    if (companyLength > 0) {
      // 公司列表加载完成后，尝试处理公司信息
      processCompanyInfo();
    }
    if (departmentLength > 0) {
      // 部门列表加载完成后，尝试处理部门信息
      processDepartmentInfo();

      // 部门列表加载完成后，也尝试处理岗位信息
      await processPositionInfo();
    }
  },
);

// 监听原数据变化，当数据加载完成后重新处理部门和公司信息回显
watch(
  () => originalData.value,
  async (newData) => {
    if (newData) {
      // 重新处理公司和部门信息回显
      processCompanyInfo();
      processDepartmentInfo();

      // 也处理岗位信息回显
      await processPositionInfo();
    }
  },
  { immediate: false },
);

// 页面加载时获取数据
onMounted(async () => {
  // 并行加载选项数据、公司列表和部门列表
  await Promise.all([
    initializeOptions(),
    loadCompanyList(),
    loadDepartmentList(),
  ]);

  // 加载调岗调薪申请详情
  if (transferId.value) {
    const result = await loadTransferDetail(transferId.value);
    if (!result.success) {
      uni.showToast({
        title: "加载数据失败",
        icon: "none",
      });
    } else {
      // 保存审核权限标识
      isMyApprove.value = result.isMyApprove || false;

      // 处理公司信息、部门信息回显
      processCompanyInfo();
      processDepartmentInfo();

      // 重要：等待一个tick确保formData已经完全更新，然后处理岗位信息
      await new Promise((resolve) => setTimeout(resolve, 50));
      await processPositionInfo();

      // 根据加载的调整类型更新表单分组（formSections 是computed属性，会自动更新）
      if (formData.transferType) {
        // 强制触发formSections重新计算
        forceUpdateTrigger.value++;
      }
    }
  }
});

// 图片上传处理
const handleImageUpload = async (field: any, event: any) => {
  console.log("图片上传:", field.key, event);
  const files = event.tempFiles || [];

  if (files.length > 0) {
    uni.showLoading({ title: "上传中..." });

    // 获取现有的文件列表
    const existingFiles = Array.isArray(formData[field.key])
      ? formData[field.key]
      : [];
    const newFileData = [];

    // 逐一上传每个文件
    for (const file of files) {
      const filePath = file?.path || file?.tempFilePath;
      if (filePath) {
        const fileId = await uploadImage(filePath, "image");
        console.log(`${field.key}上传成功，文件ID:`, fileId);

        const fileName = file?.name || file?.fileName || "图片";
        const fileInfo = {
          name: fileName,
          url: getFileUrl(fileId),
          extname: file?.extname || "jpg",
          size: file?.size || 0,
          fileID: fileId,
        };
        newFileData.push(fileInfo);
      }
    }

    // 将新上传的文件追加到现有文件列表
    formData[field.key] = [...existingFiles, ...newFileData];

    uni.hideLoading();

    if (newFileData.length > 0) {
      uni.showToast({
        title: `成功上传 ${newFileData.length} 个文件`,
        icon: "success",
      });
    }
  }
};

const handleImageSuccess = (_field: any, _event: any) => {
  // 图片上传成功回调（由于已在handleImageUpload中处理，这里可以为空或进行额外处理）
  console.log("图片上传成功回调:", _field?.key, _event);
};

const handleImageFail = (_field: any, _event: any) => {
  // 图片上传失败回调
  console.log("图片上传失败回调:", _field?.key, _event);
  uni.showToast({
    title: "图片上传失败，请重试",
    icon: "none",
  });
};

const handleImageDelete = (field: any, event: any) => {
  console.log("图片删除:", field.key, event);
  // 清空表单数据
  formData[field.key] = [];
  uni.showToast({
    title: "图片已删除",
    icon: "success",
  });
};

// 文件上传处理
const handleFileUpload = async (field: any, event: any) => {
  console.log("文件上传:", field.key, event);
  const files = event.tempFiles || [];

  if (files.length > 0) {
    uni.showLoading({ title: "上传中..." });

    // 只处理第一个文件（因为限制了maxCount为1）
    const file = files[0];
    const filePath = file?.path || file?.tempFilePath;

    if (filePath) {
      try {
        const fileId = await uploadImage(filePath, "file");
        console.log(`${field.key}上传成功，文件ID:`, fileId);

        const fileName = file?.name || file?.fileName || "文件";
        const fileInfo = {
          name: fileName,
          url: getFileUrl(fileId),
          extname: file?.extname || "pdf",
          size: file?.size || 0,
          fileID: fileId,
        };

        // 对于证明文件字段，直接保存单个文件对象，不使用数组
        if (field.key === "supportingDocument") {
          formData[field.key] = fileInfo;
        } else {
          // 其他文件字段保持原有逻辑（数组格式）
          formData[field.key] = [fileInfo];
        }

        uni.hideLoading();
        uni.showToast({
          title: "文件上传成功",
          icon: "success",
        });
      } catch (error) {
        uni.hideLoading();
        uni.showToast({
          title: "文件上传失败，请重试",
          icon: "none",
        });
      }
    } else {
      uni.hideLoading();
    }
  }
};

const handleFileSuccess = (_field: any, _event: any) => {
  // 文件上传成功回调（由于已在handleFileUpload中处理，这里可以为空或进行额外处理）
  console.log("文件上传成功回调:", _field?.key, _event);
};

const handleFileFail = (_field: any, _event: any) => {
  // 文件上传失败回调
  console.log("文件上传失败回调:", _field?.key, _event);
  uni.showToast({
    title: "文件上传失败，请重试",
    icon: "none",
  });
};

const handleFileDelete = (field: any, event: any) => {
  console.log("文件删除:", field.key, event);

  // 对于证明文件字段，设置为null；其他字段设置为空数组
  if (field.key === "supportingDocument") {
    formData[field.key] = null;
  } else {
    formData[field.key] = [];
  }

  uni.showToast({
    title: "文件已删除",
    icon: "success",
  });
};

// 附件上传处理（单文件上传）
const handleAttachmentUpload = async (field: any, files: any[]) => {
  console.log("附件上传:", field.key, files);

  if (files.length === 0) return;

  // 单文件上传限制
  if (files.length > 1) {
    uni.showToast({
      title: "仅支持上传1个文件",
      icon: "none",
      duration: 3000,
    });
    return;
  }

  uni.showLoading({ title: "上传中..." });

  try {
    const file = files[0];
    const filePath = file?.path || file?.tempFilePath;
    
    if (filePath) {
      const fileId = await uploadImage(filePath, "file");
      console.log(`${field.key}上传成功，文件ID:`, fileId);

      const fileName = file?.name || file?.fileName || "文件";
      const attachmentInfo = {
        name: fileName,
        url: getFileUrl(fileId),
        extname: file?.extname || "pdf",
        size: file?.size || 0,
        fileID: fileId, // 文件ID用于后端提交
        id: fileId,
      };

      // 单文件上传，直接替换现有文件
      formData[field.key] = [attachmentInfo];

      uni.hideLoading();
      uni.showToast({
        title: "证明文件上传成功",
        icon: "success",
      });
    }
  } catch (error) {
    console.error("文件上传失败:", error);
    uni.hideLoading();
    uni.showToast({
      title: "文件上传失败，请重试",
      icon: "none",
    });
  }
};

// 附件删除处理
const handleAttachmentDelete = (field: any, attachment: any, index: number) => {
  console.log("附件删除:", field.key, attachment, index);
  // 单文件删除，设置为空数组
  formData[field.key] = [];
  uni.showToast({
    title: "证明文件已删除",
    icon: "success",
  });
};

// 附件预览处理
const handleAttachmentPreview = (field: any, attachment: any) => {
  console.log("附件预览:", field.key, attachment);
  // 附件组件内部已经处理了预览逻辑，这里可以做额外的处理
};

// 通用的审核处理方法
const performAudit = async (actionName: string) => {
  try {
    const loadingTitle = actionName === "同意" ? "提交中..." : "取消中...";
    uni.showLoading({ title: loadingTitle });

    // 确保有原始数据（包含BillStatus和WorkflowStatus）
    if (!originalData.value) {
      uni.hideLoading();
      uni.showToast({
        title: "缺少原始数据，请重新加载页面",
        icon: "none",
      });
      return;
    }

    // 构造approve接口请求参数
    // 1. 先使用用户编辑的表单数据构造基础Entity
    const editData = convertFormDataToApiFormatForEdit();

    // 2. 然后覆盖状态字段，使用原始数据中的状态信息
    editData.Entity.BillStatus = originalData.value.BillStatus;
    editData.Entity.WorkflowStatus = originalData.value.WorkflowStatus;

    const requestData: ISysHrTransferRequestBillVm = {
      ActionName: actionName,
      Entity: editData.Entity, // 使用用户编辑的数据 + 原始状态字段
      IsMyApprove: isMyApprove.value, // 使用从详情接口获取的审核权限标识
      Remark: null, // 不需要备注弹框
    };

    // 调用approve接口
    const result = await api.approve(requestData);

    uni.hideLoading();

    if (result) {
      // 重新调用search接口获取最新的完整列表数据
      try {
        const searchResponse = await search({});
        if (searchResponse && searchResponse.length > 0) {
          // 发送完整列表数据更新事件
          ResignInfoEvents.emit("refresh", {
            id: result.ID || "",
            data: searchResponse,
            customAction: actionName === "同意" ? "approve" : "reject",
          });
        }
      } catch (error) {
        // 如果获取失败，仍然发送简单的刷新事件作为备用方案
        ResignInfoEvents.emit("refresh", {
          id: result.ID || "",
          customAction: actionName === "同意" ? "approve" : "reject",
        });
      }

      const successTitle = actionName === "同意" ? "提交成功" : "取消成功";
      uni.showToast({
        title: successTitle,
        icon: "success",
        success: () => {
          setTimeout(() => {
            uni.navigateBack();
          }, 1000);
        },
      });
    } else {
      const errorTitle =
        actionName === "同意" ? "提交失败，请重试" : "取消失败，请重试";
      uni.showToast({
        title: errorTitle,
        icon: "none",
      });
    }
  } catch (error) {
    uni.hideLoading();
    const errorTitle =
      actionName === "同意" ? "提交失败，请重试" : "取消失败，请重试";
    uni.showToast({
      title: errorTitle,
      icon: "error",
    });
  }
};

// 编辑保存方法
const performEdit = async (isSubmit: boolean = false) => {
  try {
    // 如果是提交操作，需要先进行动态验证
    if (isSubmit) {
      const transferType = formData.transferType || "";
      const validationResult = validateDynamicFormFields(transferType, "edit");

      if (!validationResult.valid) {
        // 显示第一个错误信息
        if (validationResult.firstErrorMessage) {
          uni.showToast({
            title: validationResult.firstErrorMessage,
            icon: "none",
            duration: 2000,
          });
        }
        return;
      }
    }

    const loadingTitle = isSubmit ? "提交中..." : "保存中...";
    uni.showLoading({ title: loadingTitle });

    // 确保有原始数据
    if (!originalData.value) {
      uni.hideLoading();
      uni.showToast({
        title: "缺少原始数据，请重新加载页面",
        icon: "none",
      });
      return;
    }

    // 构造Edit接口请求参数
    const editData = convertFormDataToApiFormatForEdit();

    // 确保使用原始数据中的状态字段
    editData.Entity.BillStatus = originalData.value.BillStatus;
    editData.IsMyApprove = isMyApprove.value; // 使用从详情接口获取的IsMyApprove值

    // 根据操作类型设置WorkflowStatus
    if (isSubmit) {
      // 提交操作：设置WorkflowStatus为"提交中"
      editData.Entity.WorkflowStatus = "提交中";
    } else {
      // 保存操作：使用原始的WorkflowStatus
      editData.Entity.WorkflowStatus = originalData.value.WorkflowStatus;
    }

    // 调用Edit接口
    const result = await api.edit(editData);

    uni.hideLoading();

    if (result) {
      // 重新调用search接口获取最新的完整列表数据
      try {
        const searchResponse = await search({});
        if (searchResponse && searchResponse.length > 0) {
          // 发送完整列表数据更新事件
          ResignInfoEvents.emit("refresh", {
            id: result.ID || "",
            data: searchResponse,
            customAction: isSubmit ? "submit" : "save",
          });
        }
      } catch (error) {
        // 如果获取失败，仍然发送简单的刷新事件作为备用方案
        ResignInfoEvents.emit("refresh", {
          id: result.ID || "",
          customAction: isSubmit ? "submit" : "save",
        });
      }

      const successTitle = isSubmit ? "提交成功" : "保存成功";
      uni.showToast({
        title: successTitle,
        icon: "success",
        success: () => {
          if (isSubmit) {
            // 提交成功后跳转页面
            setTimeout(() => {
              uni.navigateBack();
            }, 1000);
          }
          // 保存成功后不跳转页面
        },
      });
    } else {
      const errorTitle = isSubmit ? "提交失败，请重试" : "保存失败，请重试";
      uni.showToast({
        title: errorTitle,
        icon: "none",
      });
    }
  } catch (error) {
    uni.hideLoading();
    const errorTitle = isSubmit ? "提交失败，请重试" : "保存失败，请重试";
    uni.showToast({
      title: errorTitle,
      icon: "error",
    });
  }
};

// 同意操作
const handleApprove = async () => {
  await performAudit("同意");
};

// 拒绝操作
const handleReject = async () => {
  await performAudit("拒绝");
};

// 表单操作处理
const handleFormAction = (action: any) => {
  switch (action.key) {
    case "save":
      handleSaveAction();
      break;
    case "submit":
      handleSubmitAction();
      break;
    default:
      break;
  }
};

// 保存按钮处理方法
const handleSaveAction = async () => {
  if (isMyApprove.value) {
    // 如果IsMyApprove为true，调用拒绝接口
    await handleReject();
  } else {
    // 如果IsMyApprove为false，调用编辑保存接口
    await performEdit(false);
  }
};

// 提交按钮处理方法
const handleSubmitAction = async () => {
  if (isMyApprove.value) {
    // 如果IsMyApprove为true，调用同意接口
    await handleApprove();
  } else {
    // 如果IsMyApprove为false，调用编辑提交接口（WorkflowStatus设为"提交中"）
    await performEdit(true);
  }
};
</script>

<style lang="scss" scoped>
.form-container {
  flex: 1;
  padding: 16px;
  overflow-y: auto;
  // 为固定底部按钮预留空间：按钮44px + 上下padding32px + 边框1px + 缓冲15px + 安全区域
  padding-bottom: calc(92px + constant(safe-area-inset-bottom));
  padding-bottom: calc(92px + env(safe-area-inset-bottom));
}
</style>
